/**
 * 订单实时监听工具
 * 采用长轮询模式实现
 * 间隔3秒查询一次，支持断线重试
 */

let pollInterval = null
let isWatching = false
let lastOrders = []
let isInitialized = false  // 标记是否已初始化

/**
 * 启动订单监听
 * @param {Object} options
 * @param {string} options.userId - 用户ID（用户端使用）
 * @param {string} options.role - 用户角色（chef/user）
 * @param {Function} options.onOrderCreated - 新订单创建回调
 * @param {Function} options.onOrderUpdated - 订单更新回调
 */
export const startOrderWatch = async (options = {}) => {
  const { userId, role, onOrderCreated, onOrderUpdated } = options

  if (isWatching) {
    return
  }

  try {
    isWatching = true
    isInitialized = false  // 重置初始化标记
    
    // 立即执行一次初始化（不触发回调）
    await initializeOrderCache(userId, role)
    isInitialized = true
    
    // 启动定时轮询（每3秒）
    pollInterval = setInterval(async () => {
      await executePolling(userId, role, onOrderCreated, onOrderUpdated)
    }, 3000)
    
    return true
  } catch (err) {
    isWatching = false
    return false
  }
}

/**
 * 初始化订单缓存（第一次调用，不触发回调）
 */
const initializeOrderCache = async (userId, role) => {
  try {
    const db = uniCloud.database()
    const result = await db.collection('food-order').get()
    
    // 处理查询结果
    let allOrders = []
    
    if (result && typeof result === 'object') {
      if (result.result && Array.isArray(result.result.data)) {
        allOrders = result.result.data
      }
      else if (Array.isArray(result.data)) {
        allOrders = result.data
      }
      else if (Array.isArray(result)) {
        allOrders = result
      }
      else if (result.data && typeof result.data === 'object' && !Array.isArray(result.data)) {
        allOrders = [result.data]
      }
      else {
        allOrders = []
      }
    }
    
    if (!Array.isArray(allOrders)) {
      allOrders = []
    }
    
    // 在客户端过滤订单
    let currentOrders = allOrders
    if (role === 'user' && userId) {
      currentOrders = allOrders.filter(o => o.user_id === userId)
    }
    
    // 按创建时间排序（最新的在前）
    currentOrders = currentOrders.sort((a, b) => {
      return new Date(b.create_date) - new Date(a.create_date)
    })
    
    // 只初始化缓存，不触发回调
    lastOrders = JSON.parse(JSON.stringify(currentOrders))
  } catch (err) {
    // 忽略错误
  }
}

/**
 * 执行一次轮询检查
 */
const executePolling = async (userId, role, onOrderCreated, onOrderUpdated) => {
  try {
    const db = uniCloud.database()
    const result = await db.collection('food-order').get()
    
    // 处理查询结果 - UniCloud 返回 { result: { data: [...] } }
    let allOrders = []
    
    if (result && typeof result === 'object') {
      // 检查是否是 { result: { data: [...] } } 格式
      if (result.result && Array.isArray(result.result.data)) {
        allOrders = result.result.data
      }
      // 检查是否是 { data: [...] } 格式
      else if (Array.isArray(result.data)) {
        allOrders = result.data
      }
      // 检查是否是直接数组格式
      else if (Array.isArray(result)) {
        allOrders = result
      }
      // 单条对象格式
      else if (result.data && typeof result.data === 'object' && !Array.isArray(result.data)) {
        allOrders = [result.data]
      }
      // 无法识别的格式
      else {
        allOrders = []
      }
    } else {
      allOrders = []
    }
    
    if (!Array.isArray(allOrders)) {
      allOrders = []
    }
    
    // 在客户端过滤订单
    let currentOrders = allOrders
    if (role === 'user' && userId) {
      currentOrders = allOrders.filter(o => o.user_id === userId)
    }
    
    // 按创建时间排序（最新的在前）
    currentOrders = currentOrders.sort((a, b) => {
      return new Date(b.create_date) - new Date(a.create_date)
    })
    
    // 检查新订单或更新的订单
    currentOrders.forEach(order => {
      const oldOrder = lastOrders.find(o => o._id === order._id)
      
      if (!oldOrder) {
        // 新订单
        if (onOrderCreated) {
          onOrderCreated(order)
        }
      } else if (JSON.stringify(oldOrder) !== JSON.stringify(order)) {
        // 订单已更新
        if (onOrderUpdated) {
          onOrderUpdated(order)
        }
      }
    })
    
    // 更新缓存
    lastOrders = JSON.parse(JSON.stringify(currentOrders))
  } catch (err) {
    // 忽略错误，继续轮询
  }
}

/**
 * 停止订单监听
 */
export const stopOrderWatch = () => {
  if (pollInterval) {
    clearInterval(pollInterval)
    pollInterval = null
  }
  
  isWatching = false
  isInitialized = false
  lastOrders = []
}

/**
 * 检查监听是否活跃
 */
export const isOrderWatchActive = () => {
  return isWatching
}

export default {
  startOrderWatch,
  stopOrderWatch,
  isOrderWatchActive
}
